\documentclass[a4paper, 12pt]{article}


\usepackage[francais]{babel}	% Langue
\usepackage[utf8]{inputenc}	% Encodage du texte
\usepackage[T1]{fontenc}		% Encodage de police
\usepackage{lmodern}			% Police

%\usepackage{textcomp}		% Symboles
%\usepackage{url}			% URLs
\usepackage{graphicx}		% Images
%\usepackage[empty]{fullpage}	% Pleine page
%\usepackage{nopageno}		% Pagination
%\usepackage{multirow}		% Tableau complexe
%\usepackage{caption}
%\usepackage{array}


\title{Hexxagon\\MOIA}
\author{\bsc{Boujedli} Najim \and \bsc{Paneri} Jérémy}
\date{Master 1 Informatique\\ 2012 -- 2013}

\begin{document}
\maketitle

\begin{figure}[b]
   \centering\includegraphics[scale=0.2]{ufc.png}
\end{figure}

\thispagestyle{empty}
\newpage


% CONTENU %

\section{Présentation générale}

Hexxagon est un jeu de plateau, où le terrain de jeu est constitué de cases de forme hexagonale. Chaque joueur commence avec trois pièces, et peut faire deux sortes de mouvements : un déplacement sur une case voisine (qui duplique sa pièce) et un saut sur une case plus lointaine. À chaque mouvement, les pièces voisines à la pièce déplacée sont capturées, et la partie est terminée lorsque l'un des deux joueurs ne peut plus bouger.

Ce projet comporte deux parties, une de réseau (C/Java/Jasper) et une intelligence artificielle gérant le plateau en Prolog. Ce rapport porte sur la deuxième partie de ce travail, et présente le fonctionnement général de notre programme.


\section{Représentation du jeu}

\subsection{Plateau}

Dès la conception, il a fallu s'interroger sur la représentation du plateau et du mouvement des pièces. En effet dans le jeu les cases sont hexagonales (6 côtés), alors que de manière générale l'informatique utilise des tableaux et des matrices (cases à 4 côtés).

Après «conversion», le plateau est donc représenté de la manière suivante :

\begin{center}
\begin{tabular}{|c|c|c|c|c|c|c|c|c|}
\hline
	&		&		&		&	4,0	&	5,0	&	6,0	&	7,0	&	8,0	\\
\hline
	&		&		&	3,1	&	4,1	&	5,1	&	6,1	&	7,1	&	8,1	\\
\hline
	&		&	2,2	&	3,2	&	4,2	&	5,2	&	6,2	&	7,2	&	8,2	\\
\hline
	&	1,3	&	2,3	&	3,3	&	4,3	&		&	6,3	&	7,3	&	8,3	\\
\hline
0,4	&	1,4	&	2,4	&		&	4,4	&	5,4	&	6,4	&	7,4	&	8,4	\\
\hline
0,5	&	1,5	&	2,5	&	3,5	&		&	5,5	&	6,5	&	7,5	&		\\
\hline
0,6	&	1,6	&	2,6	&	3,6	&	4,6	&	5,6	&	6,6	&		&		\\
\hline
0,7	&	1,7	&	2,7	&	3,7	&	4,7	&	5,7	&		&		&		\\
\hline
0,8	&	1,8	&	2,8	&	3,8	&	4,8	&		&		&		&		\\
\hline

\end{tabular}
\end{center}

Par rapport à l'énoncé, nous commençons la numérotation à 0 et utilisons uniquement des chiffres, pas de lettres. Ainsi par exemple, la case \texttt{[C,7]} correspond à la case \texttt{[2,6]} de notre plateau. Les cases vides ne sont pas accessibles et sont interdites d'accès.

En Prolog, cette représentation prend simplement la forme d'une grosse liste contenant des sous-listes à deux éléments représentant les coordonnées (\texttt{[X,Y]}).


\subsection{Pièces et mouvements}

De la même manière, les déplacements et sauts d'une pièce doivent être adaptés pour passer d'un hexagone à une matrice :

\begin{center}
\begin{tabular}{|c|c|c|c|c|}
\hline
	&		&	S	&	S	&	S	\\
\hline
	&	S	&	D	&	D	&	S	\\
\hline
S	&	D	&	P	&	D	&	S	\\
\hline
S	&	D	&	D	&	S	&		\\
\hline
S	&	S	&	S	&		&		\\
\hline

\end{tabular}
\end{center}

\texttt{P} étant la position de la pièce, \texttt{D} ses possibilités de déplacement et \texttt{S} ses possibilités de saut. Pour vérifier qu'un coup est bien valide, on fait donc varier les coordonnées de la pièce ($\pm$ 1 ou 2) en vérifiant à la fois que la case résultat appartient bien au plateau, et qu'aucune pièce ne se trouve déjà à cet endroit.



\section{Déroulement d'un match}

\subsection{Appel Jasper}

Le prédicat d'entrée du programme se nomme \texttt{jouer}, qui existe en deux versions. La «principale» prend 9 paramètres :

\begin{enumerate}
	\item Liste des pièces du plateau, avant le coup de l'adversaire.
	
	\item Case de départ de la pièce que l'adversaire a bougé.
	
	\item Case d'arrivée de cette même pièce.
	
	\item Type du coup de l'adversaire (déplacement ou saut).
	
	\item Liste des pièces du plateau, après le coup du joueur.
	
	\item Case de départ de la pièce que le joueur bouge.
	
	\item Case d'arrivée de cette même pièce.
	
	\item Type du coup du joueur (déplacement, saut, gagné, perdu ou égalité).
	
	\item Booléen (0 ou 1) indiquant si le joueur est bloqué après son coup.
\end{enumerate}

Les quatre premiers arguments sont fournis par la partie SCS via Jasper ; les cinq derniers sont les résultats calculés par le programme Prolog. En particulier, le plateau résultat n'est jamais transmis à l'arbitre : il est simplement sauvegardé et renvoyé tel quel dans le plateau initial au tour suivant. Ceci est dû au fait que le programme Prolog est réexécuté de zéro à chaque fois.

Le deuxième prédicat est utilisé uniquement dans les cas où le joueur commence la partie, et prend moins de paramètres. Le programme Prolog considère que l'on est toujours le joueur 1 : c'est donc l'appel Jasper qui doit adapter le plateau de départ, en changeant ou non le propriétaire des pièces au premier tour.


\subsection{Gestion des coups}

Le coup de l'adversaire est appliqué directement au plateau, «sans se poser de questions». En effet, si le coup est envoyé au programme Prolog c'est qu'il est forcément valide : il aurait été intercepté par l'arbitre et la partie SCS dans le cas contraire.

L'étape d'après est la plus importante et détermine le coup (valide) à jouer pour ce tour. Ce coup est ensuite appliqué, et de la même manière que précédemment, si le programme Prolog est exécuté c'est qu'il reste au moins un mouvement possible au joueur.

Pour chaque mouvement effectué, suit la séquence de capture. Pour cela on reconstruit un nouveau plateau, où pour chaque pièce voisine de la case d'arrivée, on modifie le propriétaire vers celui du joueur (\texttt{[X,Y,P]}).



\subsection{Fin de partie}

Après avoir bougé les pièces, il faut déterminer si la partie est terminée ou non. Plusieurs cas de terminaison sont possibles :

\begin{itemize}
	\item Le plateau peut être entièrement rempli, si la somme des scores des deux joueurs est égale à 58 (soit le nombre de cases du plateau). C'est d'une certaine manière le seul cas où les deux joueurs sont bloqués en même temps.
	
	\item Le joueur peut se bloquer lui-même s'il n'a plus aucun mouvement possible. Dans ce cas, les cases vides reviennent à l'adversaire et on indique qu'on est bloqué.
	
	\item L'adversaire est bloqué ; les cases restantes reviennent donc au joueur. S'il ne possède plus aucune pièce suite au mouvement du joueur, on considère que c'est une forme de blocage.
\end{itemize}

Dans tous ces cas le gagnant est déterminé en fonction du joueur ayant le plus de cases en sa possession, et est placé dans la variable indiquant le type du coup joué. Si aucun ne s'applique, alors la propriété du coup reste la même et la partie peut continuer au tour suivant.




\section{Intelligence artificielle}

L'intelligence artificielle de notre programme est très simple. Grâce à un \texttt{findall}, on fait la liste de tous les coup possibles à cet instant. Un coup comprend les coordonnées de départ, d'arrivée, son type (déplacement ou saut) ainsi que sa valeur.

La valeur d'un coup est calculée en fonction du nombre de cases adverses qu'il est possible de capturer avec ce mouvement. Ensuite, nous récupérons le coup ayant la plus grande valeur : c'est lui qui est ensuite joué.


\end{document}
